home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / threading.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  25.0 KB  |  702 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import sys as _sys
  5.  
  6. try:
  7.     import thread
  8. except ImportError:
  9.     del _sys.modules[__name__]
  10.     raise 
  11.  
  12. from StringIO import StringIO as _StringIO
  13. from time import time as _time, sleep as _sleep
  14. from traceback import print_exc as _print_exc
  15. __all__ = [
  16.     'activeCount',
  17.     'Condition',
  18.     'currentThread',
  19.     'enumerate',
  20.     'Event',
  21.     'Lock',
  22.     'RLock',
  23.     'Semaphore',
  24.     'BoundedSemaphore',
  25.     'Thread',
  26.     'Timer',
  27.     'setprofile',
  28.     'settrace']
  29. _start_new_thread = thread.start_new_thread
  30. _allocate_lock = thread.allocate_lock
  31. _get_ident = thread.get_ident
  32. ThreadError = thread.error
  33. del thread
  34. _VERBOSE = False
  35.  
  36. class _Verbose(object):
  37.     
  38.     def __init__(self, verbose = None):
  39.         pass
  40.  
  41.     
  42.     def _note(self, *args):
  43.         pass
  44.  
  45.  
  46. _profile_hook = None
  47. _trace_hook = None
  48.  
  49. def setprofile(func):
  50.     global _profile_hook
  51.     _profile_hook = func
  52.  
  53.  
  54. def settrace(func):
  55.     global _trace_hook
  56.     _trace_hook = func
  57.  
  58. Lock = _allocate_lock
  59.  
  60. def RLock(*args, **kwargs):
  61.     return _RLock(*args, **kwargs)
  62.  
  63.  
  64. class _RLock(_Verbose):
  65.     
  66.     def __init__(self, verbose = None):
  67.         _Verbose.__init__(self, verbose)
  68.         self._RLock__block = _allocate_lock()
  69.         self._RLock__owner = None
  70.         self._RLock__count = 0
  71.  
  72.     
  73.     def __repr__(self):
  74.         if self._RLock__owner:
  75.             pass
  76.         return '<%s(%s, %d)>' % (self.__class__.__name__, self._RLock__owner.getName(), self._RLock__count)
  77.  
  78.     
  79.     def acquire(self, blocking = 1):
  80.         me = currentThread()
  81.         if self._RLock__owner is me:
  82.             self._RLock__count = self._RLock__count + 1
  83.             return 1
  84.         
  85.         rc = self._RLock__block.acquire(blocking)
  86.         if rc:
  87.             self._RLock__owner = me
  88.             self._RLock__count = 1
  89.         
  90.         return rc
  91.  
  92.     
  93.     def release(self):
  94.         me = currentThread()
  95.         self._RLock__count = count = self._RLock__count - 1
  96.         if not count:
  97.             self._RLock__owner = None
  98.             self._RLock__block.release()
  99.         
  100.  
  101.     
  102.     def _acquire_restore(self, .2):
  103.         (count, owner) = .2
  104.         self._RLock__block.acquire()
  105.         self._RLock__count = count
  106.         self._RLock__owner = owner
  107.  
  108.     
  109.     def _release_save(self):
  110.         count = self._RLock__count
  111.         self._RLock__count = 0
  112.         owner = self._RLock__owner
  113.         self._RLock__owner = None
  114.         self._RLock__block.release()
  115.         return (count, owner)
  116.  
  117.     
  118.     def _is_owned(self):
  119.         return self._RLock__owner is currentThread()
  120.  
  121.  
  122.  
  123. def Condition(*args, **kwargs):
  124.     return _Condition(*args, **kwargs)
  125.  
  126.  
  127. class _Condition(_Verbose):
  128.     
  129.     def __init__(self, lock = None, verbose = None):
  130.         _Verbose.__init__(self, verbose)
  131.         if lock is None:
  132.             lock = RLock()
  133.         
  134.         self._Condition__lock = lock
  135.         self.acquire = lock.acquire
  136.         self.release = lock.release
  137.         
  138.         try:
  139.             self._release_save = lock._release_save
  140.         except AttributeError:
  141.             pass
  142.  
  143.         
  144.         try:
  145.             self._acquire_restore = lock._acquire_restore
  146.         except AttributeError:
  147.             pass
  148.  
  149.         
  150.         try:
  151.             self._is_owned = lock._is_owned
  152.         except AttributeError:
  153.             pass
  154.  
  155.         self._Condition__waiters = []
  156.  
  157.     
  158.     def __repr__(self):
  159.         return '<Condition(%s, %d)>' % (self._Condition__lock, len(self._Condition__waiters))
  160.  
  161.     
  162.     def _release_save(self):
  163.         self._Condition__lock.release()
  164.  
  165.     
  166.     def _acquire_restore(self, x):
  167.         self._Condition__lock.acquire()
  168.  
  169.     
  170.     def _is_owned(self):
  171.         if self._Condition__lock.acquire(0):
  172.             self._Condition__lock.release()
  173.             return False
  174.         else:
  175.             return True
  176.  
  177.     
  178.     def wait(self, timeout = None):
  179.         currentThread()
  180.         waiter = _allocate_lock()
  181.         waiter.acquire()
  182.         self._Condition__waiters.append(waiter)
  183.         saved_state = self._release_save()
  184.         
  185.         try:
  186.             if timeout is None:
  187.                 waiter.acquire()
  188.             else:
  189.                 endtime = _time() + timeout
  190.                 delay = 0.00050000000000000001
  191.                 while True:
  192.                     gotit = waiter.acquire(0)
  193.                     if gotit:
  194.                         break
  195.                     
  196.                     remaining = endtime - _time()
  197.                     if remaining <= 0:
  198.                         break
  199.                     
  200.                     delay = min(delay * 2, remaining, 0.050000000000000003)
  201.                     _sleep(delay)
  202.                 if not gotit:
  203.                     
  204.                     try:
  205.                         self._Condition__waiters.remove(waiter)
  206.                     except ValueError:
  207.                         pass
  208.                     except:
  209.                         None<EXCEPTION MATCH>ValueError
  210.                     
  211.  
  212.                 None<EXCEPTION MATCH>ValueError
  213.         finally:
  214.             self._acquire_restore(saved_state)
  215.  
  216.  
  217.     
  218.     def notify(self, n = 1):
  219.         currentThread()
  220.         _Condition__waiters = self._Condition__waiters
  221.         waiters = _Condition__waiters[:n]
  222.         if not waiters:
  223.             return None
  224.         
  225.         if not n != 1 and 's':
  226.             pass
  227.         self._note('%s.notify(): notifying %d waiter%s', self, n, '')
  228.         for waiter in waiters:
  229.             waiter.release()
  230.             
  231.             try:
  232.                 _Condition__waiters.remove(waiter)
  233.             continue
  234.             except ValueError:
  235.                 continue
  236.             
  237.  
  238.         
  239.  
  240.     
  241.     def notifyAll(self):
  242.         self.notify(len(self._Condition__waiters))
  243.  
  244.  
  245.  
  246. def Semaphore(*args, **kwargs):
  247.     return _Semaphore(*args, **kwargs)
  248.  
  249.  
  250. class _Semaphore(_Verbose):
  251.     
  252.     def __init__(self, value = 1, verbose = None):
  253.         _Verbose.__init__(self, verbose)
  254.         self._Semaphore__cond = Condition(Lock())
  255.         self._Semaphore__value = value
  256.  
  257.     
  258.     def acquire(self, blocking = 1):
  259.         rc = False
  260.         self._Semaphore__cond.acquire()
  261.         while self._Semaphore__value == 0:
  262.             if not blocking:
  263.                 break
  264.             
  265.             self._Semaphore__cond.wait()
  266.         self._Semaphore__value = self._Semaphore__value - 1
  267.         rc = True
  268.         self._Semaphore__cond.release()
  269.         return rc
  270.  
  271.     
  272.     def release(self):
  273.         self._Semaphore__cond.acquire()
  274.         self._Semaphore__value = self._Semaphore__value + 1
  275.         self._Semaphore__cond.notify()
  276.         self._Semaphore__cond.release()
  277.  
  278.  
  279.  
  280. def BoundedSemaphore(*args, **kwargs):
  281.     return _BoundedSemaphore(*args, **kwargs)
  282.  
  283.  
  284. class _BoundedSemaphore(_Semaphore):
  285.     
  286.     def __init__(self, value = 1, verbose = None):
  287.         _Semaphore.__init__(self, value, verbose)
  288.         self._initial_value = value
  289.  
  290.     
  291.     def release(self):
  292.         if self._Semaphore__value >= self._initial_value:
  293.             raise ValueError, 'Semaphore released too many times'
  294.         
  295.         return _Semaphore.release(self)
  296.  
  297.  
  298.  
  299. def Event(*args, **kwargs):
  300.     return _Event(*args, **kwargs)
  301.  
  302.  
  303. class _Event(_Verbose):
  304.     
  305.     def __init__(self, verbose = None):
  306.         _Verbose.__init__(self, verbose)
  307.         self._Event__cond = Condition(Lock())
  308.         self._Event__flag = False
  309.  
  310.     
  311.     def isSet(self):
  312.         return self._Event__flag
  313.  
  314.     
  315.     def set(self):
  316.         self._Event__cond.acquire()
  317.         
  318.         try:
  319.             self._Event__flag = True
  320.             self._Event__cond.notifyAll()
  321.         finally:
  322.             self._Event__cond.release()
  323.  
  324.  
  325.     
  326.     def clear(self):
  327.         self._Event__cond.acquire()
  328.         
  329.         try:
  330.             self._Event__flag = False
  331.         finally:
  332.             self._Event__cond.release()
  333.  
  334.  
  335.     
  336.     def wait(self, timeout = None):
  337.         self._Event__cond.acquire()
  338.         
  339.         try:
  340.             if not (self._Event__flag):
  341.                 self._Event__cond.wait(timeout)
  342.         finally:
  343.             self._Event__cond.release()
  344.  
  345.  
  346.  
  347. _counter = 0
  348.  
  349. def _newname(template = 'Thread-%d'):
  350.     global _counter
  351.     _counter = _counter + 1
  352.     return template % _counter
  353.  
  354. _active_limbo_lock = _allocate_lock()
  355. _active = { }
  356. _limbo = { }
  357.  
  358. class Thread(_Verbose):
  359.     __initialized = False
  360.     
  361.     def __init__(self, group = None, target = None, name = None, args = (), kwargs = { }, verbose = None):
  362.         _Verbose.__init__(self, verbose)
  363.         self._Thread__target = target
  364.         if not name:
  365.             pass
  366.         self._Thread__name = str(_newname())
  367.         self._Thread__args = args
  368.         self._Thread__kwargs = kwargs
  369.         self._Thread__daemonic = self._set_daemon()
  370.         self._Thread__started = False
  371.         self._Thread__stopped = False
  372.         self._Thread__block = Condition(Lock())
  373.         self._Thread__initialized = True
  374.  
  375.     
  376.     def _set_daemon(self):
  377.         return currentThread().isDaemon()
  378.  
  379.     
  380.     def __repr__(self):
  381.         status = 'initial'
  382.         if self._Thread__started:
  383.             status = 'started'
  384.         
  385.         if self._Thread__stopped:
  386.             status = 'stopped'
  387.         
  388.         if self._Thread__daemonic:
  389.             status = status + ' daemon'
  390.         
  391.         return '<%s(%s, %s)>' % (self.__class__.__name__, self._Thread__name, status)
  392.  
  393.     
  394.     def start(self):
  395.         _active_limbo_lock.acquire()
  396.         _limbo[self] = self
  397.         _active_limbo_lock.release()
  398.         _start_new_thread(self._Thread__bootstrap, ())
  399.         self._Thread__started = True
  400.         _sleep(9.9999999999999995e-007)
  401.  
  402.     
  403.     def run(self):
  404.         if self._Thread__target:
  405.             self._Thread__target(*self._Thread__args, **self._Thread__kwargs)
  406.         
  407.  
  408.     
  409.     def __bootstrap(self):
  410.         
  411.         try:
  412.             self._Thread__started = True
  413.             _active_limbo_lock.acquire()
  414.             _active[_get_ident()] = self
  415.             del _limbo[self]
  416.             _active_limbo_lock.release()
  417.             if _trace_hook:
  418.                 self._note('%s.__bootstrap(): registering trace hook', self)
  419.                 _sys.settrace(_trace_hook)
  420.             
  421.             if _profile_hook:
  422.                 self._note('%s.__bootstrap(): registering profile hook', self)
  423.                 _sys.setprofile(_profile_hook)
  424.             
  425.             
  426.             try:
  427.                 self.run()
  428.             except SystemExit:
  429.                 pass
  430.             except:
  431.                 s = _StringIO()
  432.                 _print_exc(file = s)
  433.                 _sys.stderr.write('Exception in thread %s:\n%s\n' % (self.getName(), s.getvalue()))
  434.  
  435.         finally:
  436.             self._Thread__stop()
  437.             
  438.             try:
  439.                 self._Thread__delete()
  440.             except:
  441.                 pass
  442.  
  443.  
  444.  
  445.     
  446.     def __stop(self):
  447.         self._Thread__block.acquire()
  448.         self._Thread__stopped = True
  449.         self._Thread__block.notifyAll()
  450.         self._Thread__block.release()
  451.  
  452.     
  453.     def __delete(self):
  454.         _active_limbo_lock.acquire()
  455.         del _active[_get_ident()]
  456.         _active_limbo_lock.release()
  457.  
  458.     
  459.     def join(self, timeout = None):
  460.         self._Thread__block.acquire()
  461.         if timeout is None:
  462.             while not (self._Thread__stopped):
  463.                 self._Thread__block.wait()
  464.         else:
  465.             deadline = _time() + timeout
  466.             while not (self._Thread__stopped):
  467.                 delay = deadline - _time()
  468.                 if delay <= 0:
  469.                     break
  470.                 
  471.                 self._Thread__block.wait(delay)
  472.         self._Thread__block.release()
  473.  
  474.     
  475.     def getName(self):
  476.         return self._Thread__name
  477.  
  478.     
  479.     def setName(self, name):
  480.         self._Thread__name = str(name)
  481.  
  482.     
  483.     def isAlive(self):
  484.         if self._Thread__started:
  485.             pass
  486.         return not (self._Thread__stopped)
  487.  
  488.     
  489.     def isDaemon(self):
  490.         return self._Thread__daemonic
  491.  
  492.     
  493.     def setDaemon(self, daemonic):
  494.         self._Thread__daemonic = daemonic
  495.  
  496.  
  497.  
  498. def Timer(*args, **kwargs):
  499.     return _Timer(*args, **kwargs)
  500.  
  501.  
  502. class _Timer(Thread):
  503.     
  504.     def __init__(self, interval, function, args = [], kwargs = { }):
  505.         Thread.__init__(self)
  506.         self.interval = interval
  507.         self.function = function
  508.         self.args = args
  509.         self.kwargs = kwargs
  510.         self.finished = Event()
  511.  
  512.     
  513.     def cancel(self):
  514.         self.finished.set()
  515.  
  516.     
  517.     def run(self):
  518.         self.finished.wait(self.interval)
  519.         if not self.finished.isSet():
  520.             self.function(*self.args, **self.kwargs)
  521.         
  522.         self.finished.set()
  523.  
  524.  
  525.  
  526. class _MainThread(Thread):
  527.     
  528.     def __init__(self):
  529.         Thread.__init__(self, name = 'MainThread')
  530.         self._Thread__started = True
  531.         _active_limbo_lock.acquire()
  532.         _active[_get_ident()] = self
  533.         _active_limbo_lock.release()
  534.         import atexit
  535.         atexit.register(self._MainThread__exitfunc)
  536.  
  537.     
  538.     def _set_daemon(self):
  539.         return False
  540.  
  541.     
  542.     def _MainThread__exitfunc(self):
  543.         self._Thread__stop()
  544.         t = _pickSomeNonDaemonThread()
  545.         if t:
  546.             pass
  547.         
  548.         while t:
  549.             t.join()
  550.             t = _pickSomeNonDaemonThread()
  551.         self._Thread__delete()
  552.  
  553.  
  554.  
  555. def _pickSomeNonDaemonThread():
  556.     for t in enumerate():
  557.         if not t.isDaemon() and t.isAlive():
  558.             return t
  559.             continue
  560.     
  561.     return None
  562.  
  563.  
  564. class _DummyThread(Thread):
  565.     
  566.     def __init__(self):
  567.         Thread.__init__(self, name = _newname('Dummy-%d'))
  568.         self._Thread__started = True
  569.         _active_limbo_lock.acquire()
  570.         _active[_get_ident()] = self
  571.         _active_limbo_lock.release()
  572.  
  573.     
  574.     def _set_daemon(self):
  575.         return True
  576.  
  577.     
  578.     def join(self, timeout = None):
  579.         pass
  580.  
  581.  
  582.  
  583. def currentThread():
  584.     
  585.     try:
  586.         return _active[_get_ident()]
  587.     except KeyError:
  588.         return _DummyThread()
  589.  
  590.  
  591.  
  592. def activeCount():
  593.     _active_limbo_lock.acquire()
  594.     count = len(_active) + len(_limbo)
  595.     _active_limbo_lock.release()
  596.     return count
  597.  
  598.  
  599. def enumerate():
  600.     _active_limbo_lock.acquire()
  601.     active = _active.values() + _limbo.values()
  602.     _active_limbo_lock.release()
  603.     return active
  604.  
  605. _MainThread()
  606.  
  607. def _test():
  608.     
  609.     class BoundedQueue(_Verbose):
  610.         
  611.         def __init__(self, limit):
  612.             _Verbose.__init__(self)
  613.             self.mon = RLock()
  614.             self.rc = Condition(self.mon)
  615.             self.wc = Condition(self.mon)
  616.             self.limit = limit
  617.             self.queue = []
  618.  
  619.         
  620.         def put(self, item):
  621.             self.mon.acquire()
  622.             while len(self.queue) >= self.limit:
  623.                 self._note('put(%s): queue full', item)
  624.                 self.wc.wait()
  625.             self.queue.append(item)
  626.             self._note('put(%s): appended, length now %d', item, len(self.queue))
  627.             self.rc.notify()
  628.             self.mon.release()
  629.  
  630.         
  631.         def get(self):
  632.             self.mon.acquire()
  633.             while not (self.queue):
  634.                 self._note('get(): queue empty')
  635.                 self.rc.wait()
  636.             item = self.queue.pop(0)
  637.             self._note('get(): got %s, %d left', item, len(self.queue))
  638.             self.wc.notify()
  639.             self.mon.release()
  640.             return item
  641.  
  642.  
  643.     
  644.     class ProducerThread(Thread):
  645.         
  646.         def __init__(self, queue, quota):
  647.             Thread.__init__(self, name = 'Producer')
  648.             self.queue = queue
  649.             self.quota = quota
  650.  
  651.         
  652.         def run(self):
  653.             random = random
  654.             import random
  655.             counter = 0
  656.             while counter < self.quota:
  657.                 counter = counter + 1
  658.                 self.queue.put('%s.%d' % (self.getName(), counter))
  659.                 _sleep(random() * 1.0000000000000001e-005)
  660.  
  661.  
  662.     
  663.     class ConsumerThread(Thread):
  664.         
  665.         def __init__(self, queue, count):
  666.             Thread.__init__(self, name = 'Consumer')
  667.             self.queue = queue
  668.             self.count = count
  669.  
  670.         
  671.         def run(self):
  672.             while self.count > 0:
  673.                 item = self.queue.get()
  674.                 print item
  675.                 self.count = self.count - 1
  676.  
  677.  
  678.     NP = 3
  679.     QL = 4
  680.     NI = 5
  681.     Q = BoundedQueue(QL)
  682.     P = []
  683.     for i in range(NP):
  684.         t = ProducerThread(Q, NI)
  685.         t.setName('Producer-%d' % (i + 1))
  686.         P.append(t)
  687.     
  688.     C = ConsumerThread(Q, NI * NP)
  689.     for t in P:
  690.         t.start()
  691.         _sleep(9.9999999999999995e-007)
  692.     
  693.     C.start()
  694.     for t in P:
  695.         t.join()
  696.     
  697.     C.join()
  698.  
  699. if __name__ == '__main__':
  700.     _test()
  701.  
  702.